home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_emacs.idb / usr / freeware / share / emacs / 19.34 / lisp / mailalias.el.z / mailalias.el
Encoding:
Text File  |  1998-10-28  |  15.3 KB  |  442 lines
  1. ;;; mailalias.el --- expand and complete mailing address aliases
  2.  
  3. ;; Copyright (C) 1985, 1987, 1995, 1996 Free Software Foundation, Inc.
  4.  
  5. ;; Maintainer: FSF
  6. ;; Keywords: mail
  7.  
  8. ;; This file is part of GNU Emacs.
  9.  
  10. ;; GNU Emacs is free software; you can redistribute it and/or modify
  11. ;; it under the terms of the GNU General Public License as published by
  12. ;; the Free Software Foundation; either version 2, or (at your option)
  13. ;; any later version.
  14.  
  15. ;; GNU Emacs is distributed in the hope that it will be useful,
  16. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. ;; GNU General Public License for more details.
  19.  
  20. ;; You should have received a copy of the GNU General Public License
  21. ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22. ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23. ;; Boston, MA 02111-1307, USA.
  24.  
  25. ;;; Commentary:
  26.  
  27. ;; Basic functions for defining and expanding mail aliases.
  28. ;; These seal off the interface to the alias-definition parts of a
  29. ;; .mailrc file formatted for BSD's Mail or USL's mailx.
  30.  
  31. ;;; Code:
  32.  
  33. (require 'sendmail)
  34.  
  35. (defvar mail-names t
  36.   "Alist of local users, aliases and directory entries as available.
  37. When t this still needs to be initialized.
  38. This is the basis for `mail-complete'.")
  39.  
  40. (defvar mail-local-names t
  41.   "Alist of local users.
  42. When t this still needs to be initialized.")
  43.  
  44. (defvar mail-directory-names t
  45.   "Alist of mail address directory entries.
  46. When t this still needs to be initialized.")
  47.  
  48. (defvar mail-address-field-regexp
  49.   "^\\(Resent-\\)?\\(To\\|From\\|CC\\|BCC\\|Reply-to\\):")
  50.  
  51. (defvar mail-complete-alist
  52.   `((,mail-address-field-regexp mail-get-names pattern)
  53.     ("Newsgroups:" . (if (boundp 'gnus-active-hashtb)
  54.              gnus-active-hashtb
  55.                (if (boundp news-group-article-assoc)
  56.                news-group-article-assoc)))
  57.     ("Followup-To:" . (mail-sentto-newsgroups))
  58.     ;;("Distribution:" ???)
  59.     )
  60.   "Alist of header field and expression to return alist for completion.
  61. Expression may reference variable `pattern' which is the string being completed.
  62. If not on matching header, `mail-complete-function' gets called instead.")
  63.  
  64. (defvar mail-complete-function 'ispell-complete-word
  65.   "Function to call when completing outside `mail-complete-alist'-header.")
  66.  
  67.  
  68. (defvar mail-directory-function nil
  69.   "Function to get completions from directory service or `nil' for none.
  70. See `mail-directory-requery'.")
  71.  
  72.  
  73. ;; This is for when the directory is huge, or changes frequently.
  74. (defvar mail-directory-requery nil
  75.   "When non-`nil' call `mail-directory-function' for each completion.
  76. In that case, one argument gets passed to the function, the partial string
  77. entered so far.")
  78.  
  79.  
  80. (defvar mail-directory-process nil
  81.   "Unix command when `mail-directory-function' is `mail-directory-process'.
  82. This is a list of the form (COMMAND ARG ...), where each of the list elements
  83. is evaluated.  When `mail-directory-requery' is non-`nil', during
  84. evaluation the variable `pattern' contains the partial input being completed.
  85. This might look like
  86.  
  87.   '(remote-shell-program \"HOST\" \"-nl\" \"USER\" \"COMMAND\")
  88.  
  89. or
  90.  
  91.   '(remote-shell-program \"HOST\" \"-n\" \"COMMAND '^\" pattern \"'\")")
  92.  
  93. (defvar mail-directory-stream ()
  94.   "List of (HOST SERVICE) for stream connection to mail directory.")
  95.  
  96. (defvar mail-directory-parser nil
  97.   "How to interpret the output of `mail-directory-function'.
  98. Three types of values are possible:
  99.  
  100.   - nil means to gather each line as one name
  101.   - regexp means first \\(grouping\\) in successive matches is name
  102.   - function called at beginning of buffer that returns an alist of names")
  103.  
  104.  
  105. ;; Called from sendmail-send-it, or similar functions,
  106. ;; only if some mail aliases are defined.
  107. (defun expand-mail-aliases (beg end &optional exclude)
  108.   "Expand all mail aliases in suitable header fields found between BEG and END.
  109. Suitable header fields are `To', `From', `CC' and `BCC', `Reply-to', and
  110. their `Resent-' variants.
  111.  
  112. Optional second arg EXCLUDE may be a regular expression defining text to be
  113. removed from alias expansions."
  114.   (sendmail-sync-aliases)
  115.   (if (eq mail-aliases t)
  116.       (progn (setq mail-aliases nil) (build-mail-aliases)))
  117.   (goto-char beg)
  118.   (setq end (set-marker (make-marker) end))
  119.   (let ((case-fold-search nil))
  120.     (while (let ((case-fold-search t))
  121.          (re-search-forward mail-address-field-regexp end t))
  122.       (skip-chars-forward " \t")
  123.       (let ((beg1 (point))
  124.         end1 pos epos seplen
  125.         ;; DISABLED-ALIASES records aliases temporarily disabled
  126.         ;; while we scan text that resulted from expanding those aliases.
  127.         ;; Each element is (ALIAS . TILL-WHEN), where TILL-WHEN
  128.         ;; is where to reenable the alias (expressed as number of chars
  129.         ;; counting from END1).
  130.         (disabled-aliases nil))
  131.     (re-search-forward "^[^ \t]" end 'move)
  132.     (beginning-of-line)
  133.     (skip-chars-backward " \t\n")
  134.     (setq end1 (point-marker))
  135.     (goto-char beg1)
  136.     (while (< (point) end1)
  137.       (setq pos (point))
  138.       ;; Reenable any aliases which were disabled for ranges
  139.       ;; that we have passed out of.
  140.       (while (and disabled-aliases (> pos (- end1 (cdr (car disabled-aliases)))))
  141.         (setq disabled-aliases (cdr disabled-aliases)))
  142.       ;; EPOS gets position of end of next name;
  143.       ;; SEPLEN gets length of whitespace&separator that follows it.
  144.       (if (re-search-forward "[ \t]*[\n,][ \t]*" end1 t)
  145.           (setq epos (match-beginning 0)
  146.             seplen (- (point) epos))
  147.         (setq epos (marker-position end1) seplen 0))
  148.       (let (translation
  149.         (string (buffer-substring-no-properties pos epos)))
  150.         (if (and (not (assoc string disabled-aliases))
  151.              (setq translation
  152.                (cdr (assoc string mail-aliases))))
  153.         (progn
  154.           ;; This name is an alias.  Disable it.
  155.           (setq disabled-aliases (cons (cons string (- end1 epos))
  156.                            disabled-aliases))
  157.           ;; Replace the alias with its expansion
  158.           ;; then rescan the expansion for more aliases.
  159.           (goto-char pos)
  160.           (insert translation)
  161.           (if exclude
  162.                (let ((regexp
  163.                  (concat "\\b\\(" exclude "\\)\\b"))
  164.                 (end (point-marker)))
  165.             (goto-char pos)
  166.             (while (re-search-forward regexp end t)
  167.               (replace-match ""))
  168.             (goto-char end)))
  169.           (delete-region (point) (+ (point) (- epos pos)))
  170.           (goto-char pos))
  171.           ;; Name is not an alias.  Skip to start of next name.
  172.           (goto-char epos)
  173.           (forward-char seplen))))
  174.     (set-marker end1 nil)))
  175.     (set-marker end nil)))
  176.  
  177. ;; Called by mail-setup, or similar functions, only if the file specified
  178. ;; by mail-personal-alias-file (usually `~/.mailrc') exists.
  179. (defun build-mail-aliases (&optional file)
  180.   "Read mail aliases from personal aliases file and set `mail-aliases'.
  181. By default, this is the file specified by `mail-personal-alias-file'."
  182.   (setq file (expand-file-name (or file mail-personal-alias-file)))
  183.   (let ((buffer nil)
  184.     (obuf (current-buffer)))
  185.     (unwind-protect
  186.     (progn
  187.       (setq buffer (generate-new-buffer " mailrc"))
  188.       (set-buffer buffer)
  189.       (while file
  190.         (cond ((get-file-buffer file)
  191.            (insert (save-excursion
  192.                  (set-buffer (get-file-buffer file))
  193.                  (buffer-substring-no-properties
  194.                   (point-min) (point-max)))))
  195.           ((file-exists-p file) (insert-file-contents file))
  196.           ((file-exists-p (setq file (concat "~/" file)))
  197.            (insert-file-contents file))
  198.           (t (setq file nil)))
  199.         ;; Don't lose if no final newline.
  200.         (goto-char (point-max))
  201.         (or (eq (preceding-char) ?\n) (newline))
  202.         (goto-char (point-min))
  203.         ;; handle "\\\n" continuation lines
  204.         (while (not (eobp))
  205.           (end-of-line)
  206.           (if (= (preceding-char) ?\\)
  207.           (progn (delete-char -1) (delete-char 1) (insert ?\ ))
  208.             (forward-char 1)))
  209.         (goto-char (point-min))
  210.         ;; handle `source' directives -- Eddy/1994/May/25
  211.         (cond ((re-search-forward "^source[ \t]+" nil t)
  212.            (re-search-forward "\\S-+")
  213.            (setq file (buffer-substring-no-properties
  214.                    (match-beginning 0) (match-end 0)))
  215.            (beginning-of-line)
  216.            (insert "# ") ; to ensure we don't re-process this file
  217.            (beginning-of-line))
  218.           (t (setq file nil))))
  219.       (goto-char (point-min))
  220.       (while (re-search-forward
  221.           "^\\(a\\|alias\\|g\\|group\\)[ \t]+\\([^ \t]+\\)" nil t)
  222.         (let* ((name (match-string 2))
  223.            (start (progn (skip-chars-forward " \t") (point))))
  224.           (end-of-line)
  225.           (define-mail-alias
  226.         name
  227.         (buffer-substring-no-properties start (point))
  228.         t)))
  229.       mail-aliases)
  230.       (if buffer (kill-buffer buffer))
  231.       (set-buffer obuf))))
  232.  
  233. ;; Always autoloadable in case the user wants to define aliases
  234. ;; interactively or in .emacs.
  235. ;;;###autoload
  236. (defun define-mail-alias (name definition &optional from-mailrc-file)
  237.   "Define NAME as a mail alias that translates to DEFINITION.
  238. This means that sending a message to NAME will actually send to DEFINITION.
  239.  
  240. Normally, the addresses in DEFINITION must be separated by commas.
  241. If FROM-MAILRC-FILE is non-nil, then addresses in DEFINITION 
  242. can be separated by spaces; an address can contain spaces
  243. if it is quoted with double-quotes."
  244.  
  245.   (interactive "sDefine mail alias: \nsDefine %s as mail alias for: ")
  246.   ;; Read the defaults first, if we have not done so.
  247.   (sendmail-sync-aliases)
  248.   (if (eq mail-aliases t)
  249.       (progn
  250.     (setq mail-aliases nil)
  251.     (if (file-exists-p mail-personal-alias-file)
  252.         (build-mail-aliases))))
  253.   ;; strip garbage from front and end
  254.   (if (string-match "\\`[ \t\n,]+" definition)
  255.       (setq definition (substring definition (match-end 0))))
  256.   (if (string-match "[ \t\n,]+\\'" definition)
  257.       (setq definition (substring definition 0 (match-beginning 0))))
  258.   (let ((result '())
  259.     ;; If DEFINITION is null string, avoid looping even once.
  260.     (start (and (not (equal definition "")) 0))
  261.     (L (length definition))
  262.     end tem)
  263.     (while start
  264.       ;; If we're reading from the mailrc file, then addresses are delimited
  265.       ;; by spaces, and addresses with embedded spaces must be surrounded by
  266.       ;; double-quotes.  Otherwise, addresses are separated by commas.
  267.       (if from-mailrc-file
  268.       (if (eq ?\" (aref definition start))
  269.           (setq start (1+ start)
  270.             end (string-match "\"[ \t,]*" definition start))
  271.         (setq end (string-match "[ \t,]+" definition start)))
  272.     (setq end (string-match "[ \t\n,]*,[ \t\n,]*" definition start)))
  273.       (setq result (cons (substring definition start end) result))
  274.       (setq start (and end
  275.                (/= (match-end 0) L)
  276.                (match-end 0))))
  277.     (setq definition (mapconcat (function identity)
  278.                 (nreverse result)
  279.                 ", "))
  280.     (setq tem (assoc name mail-aliases))
  281.     (if tem
  282.     (rplacd tem definition)
  283.       (setq mail-aliases (cons (cons name definition) mail-aliases)
  284.         mail-names t))))
  285.  
  286. ;;;###autoload
  287. (defun mail-complete (arg)
  288.   "Perform completion on header field or word preceding point.
  289. Completable headers are according to `mail-complete-alist'.  If none matches
  290. current header, calls `mail-complete-function' and passes prefix arg if any."
  291.   (interactive "P")
  292.   ;; Read the defaults first, if we have not done so.
  293.   (sendmail-sync-aliases)
  294.   (if (eq mail-aliases t)
  295.       (progn
  296.     (setq mail-aliases nil)
  297.     (if (file-exists-p mail-personal-alias-file)
  298.         (build-mail-aliases))))
  299.   (let ((list mail-complete-alist))
  300.     (if (and (save-excursion (search-forward
  301.                   (concat "\n" mail-header-separator "\n")
  302.                   nil t))
  303.          (save-excursion
  304.            (if (re-search-backward "^[^\t]" nil t)
  305.            (while list
  306.              (if (looking-at (car (car list)))
  307.              (setq arg (cdr (car list))
  308.                    list ())
  309.                (setq list (cdr list)))))
  310.            arg))
  311.     (let* ((end (point))
  312.            (beg (save-excursion
  313.               (skip-chars-backward "^ \t<,:")
  314.               (point)))
  315.            (pattern (buffer-substring beg end))
  316.            completion)
  317.       (setq list (eval arg)
  318.         completion (try-completion pattern list))
  319.       (cond ((eq completion t))
  320.         ((null completion)
  321.          (message "Can't find completion for \"%s\"" pattern)
  322.          (ding))
  323.         ((not (string= pattern completion))
  324.          (delete-region beg end)
  325.          (insert completion))
  326.         (t
  327.          (message "Making completion list...")
  328.          (with-output-to-temp-buffer "*Completions*"
  329.            (display-completion-list
  330.             (all-completions pattern list)))
  331.          (message "Making completion list...%s" "done"))))
  332.       (funcall mail-complete-function arg))))
  333.  
  334. (defun mail-get-names (pattern)
  335.   "Fetch local users and global mail adresses for completion.
  336. Consults `/etc/passwd' and a directory service if one is set up via
  337. `mail-directory-function'."
  338.   (if (eq mail-local-names t)
  339.       (save-excursion
  340.     (set-buffer (generate-new-buffer " passwd"))
  341.     (insert-file-contents "/etc/passwd" nil nil nil t)
  342.     (setq mail-local-names)
  343.     (while (not (eobp))
  344.       ;;Recognize lines like
  345.       ;;  nobody:*:65534:65534::/:
  346.       ;;  +demo::::::/bin/csh
  347.       ;;  +ethanb
  348.       ;;while skipping
  349.       ;;  +@SOFTWARE
  350.       (if (looking-at "\\+?\\([^:@\n+]+\\)")
  351.           (add-to-list 'mail-local-names (list (match-string 1))))
  352.       (beginning-of-line 2))
  353.     (kill-buffer (current-buffer))))
  354.   (if (or (eq mail-names t)
  355.         (eq mail-directory-names t))
  356.       (let (directory)
  357.     (and mail-directory-function
  358.          (eq mail-directory-names t)
  359.          (setq directory
  360.            (mail-directory (if mail-directory-requery pattern))))
  361.     (if (or directory
  362.         (eq mail-names t))
  363.         (setq mail-names
  364.           (sort (append (if (consp mail-aliases) mail-aliases)
  365.                 (if (consp mail-local-names)
  366.                     mail-local-names)
  367.                 directory)
  368.             (lambda (a b)
  369.               ;; should cache downcased strings
  370.               (string< (downcase (car a))
  371.                    (downcase (car b)))))))
  372.     (or mail-directory-requery
  373.         (setq mail-directory-names directory))))
  374.   mail-names)
  375.  
  376.  
  377. (defun mail-directory (pattern)
  378.   "Call directory to get names matching PATTERN or all if `nil'.
  379. Calls `mail-directory-function' and applies `mail-directory-parser' to output."
  380.   (save-excursion
  381.     (message "Querying directory...")
  382.     (set-buffer (generate-new-buffer " *mail-directory*"))
  383.     (funcall mail-directory-function pattern)
  384.     (goto-char 1)
  385.     (let (directory)
  386.       (if (stringp mail-directory-parser)
  387.       (while (re-search-forward mail-directory-parser nil t)
  388.         (setq directory
  389.           `((,(match-string 1))
  390.             ,@directory)))
  391.     (if mail-directory-parser
  392.         (setq directory (funcall mail-directory-parser))
  393.       (while (not (eobp))
  394.         (setq directory
  395.           `((,(buffer-substring (point)
  396.                     (progn
  397.                       (forward-line)
  398.                       (if (bolp)
  399.                         (1- (point))
  400.                         (point)))))
  401.             ,@directory)))))
  402.       (kill-buffer (current-buffer))
  403.       (message "Querying directory...done")
  404.       directory)))
  405.  
  406.  
  407. (defun mail-directory-process (pattern)
  408.   "Call a Unix process to output names in directory.
  409. See `mail-directory-process'."
  410.   (apply 'call-process (eval (car mail-directory-process)) nil t nil
  411.      (mapcar 'eval (cdr mail-directory-process))))
  412.  
  413. ;; This should handle a dialog.  Currently expects port to spit out names.
  414. (defun mail-directory-stream (pattern)
  415.   "Open a stream to retrieve names in directory.
  416. See `mail-directory-stream'."
  417.   (let (mailalias-done)
  418.     (set-process-sentinel
  419.      (apply 'open-network-stream "mailalias" (current-buffer)
  420.         mail-directory-stream)
  421.      (lambda (x x)
  422.        (setq mailalias-done t)))
  423.     (while (not mailalias-done)
  424.       (sit-for .1))))
  425.  
  426. (defun mail-sentto-newsgroups ()
  427.   "Return all entries from Newsgroups: header as completion alist."
  428.   (save-excursion
  429.     (if (mail-position-on-field "newsgroups" t)
  430.     (let ((point (point))
  431.           list)
  432.       (while (< (skip-chars-backward "^:, \t\n") 0)
  433.         (setq list `((,(buffer-substring (point) point))
  434.              ,@list))
  435.         (skip-chars-backward ", \t\n")
  436.         (setq point (point)))
  437.       list))))
  438.  
  439. (provide 'mailalias)
  440.  
  441. ;;; mailalias.el ends here
  442.